In [1183]:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
from sklearn.neighbors import KNeighborsClassifier
from scipy.stats import zscore
from sklearn import metrics
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.impute import SimpleImputer
from sklearn.metrics import confusion_matrix,accuracy_score
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.tree import export_graphviz
from sklearn.externals.six import StringIO
from IPython.display import Image
import pydotplus
import graphviz
from sklearn import model_selection
from mlxtend.classifier import StackingClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import AdaBoostClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn.ensemble import GradientBoostingClassifier
1. Load the dataset
In [1184]:
park = pd.read_csv("Data-Parkinsons.csv")
In [1185]:
park.shape
Out[1185]:
In [1186]:
park.head()
Out[1186]:
2. Studying the data attributes¶
In [1187]:
park.info()
In [1188]:
park.isnull().values.any()
Out[1188]:
In [1189]:
park.describe()
Out[1189]:
The following can be understood from initial data analysis
- There are 195 entries.
- There are no null values.
- There are 22 float,1 integer,1 object column.
- The shape of the data is 8 rows and 23 columns.
3. Univariate analysis¶
In [1190]:
park["MDVP:Fo(Hz)"].describe()
Out[1190]:
In [1191]:
sns.distplot(park["MDVP:Fo(Hz)"])
Out[1191]:
In [1192]:
park["MDVP:Fhi(Hz)"].describe()
Out[1192]:
In [1193]:
sns.distplot(park["MDVP:Fhi(Hz)"])
Out[1193]:
In [1194]:
park["MDVP:Flo(Hz)"].describe()
Out[1194]:
In [1195]:
sns.distplot(park["MDVP:Flo(Hz)"])
Out[1195]:
In [1196]:
park["MDVP:Jitter(%)"].describe()
Out[1196]:
In [1197]:
sns.distplot(park["MDVP:Jitter(%)"])
Out[1197]:
In [1198]:
park["MDVP:Jitter(Abs)"].describe()
Out[1198]:
In [1199]:
sns.distplot(park["MDVP:Jitter(Abs)"])
Out[1199]:
In [1200]:
park["MDVP:RAP"].describe()
Out[1200]:
In [1201]:
sns.distplot(park["MDVP:RAP"])
Out[1201]:
In [1202]:
park["MDVP:PPQ"].describe()
Out[1202]:
In [1203]:
sns.distplot(park["MDVP:PPQ"])
Out[1203]:
In [1204]:
park["Jitter:DDP"].describe()
Out[1204]:
In [1205]:
sns.distplot(park["Jitter:DDP"])
Out[1205]:
In [1206]:
park["MDVP:Shimmer"].describe()
Out[1206]:
In [1207]:
sns.distplot(park["MDVP:Shimmer"])
Out[1207]:
In [1208]:
park["MDVP:Shimmer(dB)"].describe()
Out[1208]:
In [1209]:
sns.distplot(park["MDVP:Shimmer(dB)"])
Out[1209]:
In [1210]:
park["Shimmer:APQ3"].describe()
Out[1210]:
In [1211]:
sns.distplot(park["Shimmer:APQ3"])
Out[1211]:
In [1212]:
park["Shimmer:APQ5"].describe()
Out[1212]:
In [1213]:
sns.distplot(park["Shimmer:APQ5"])
Out[1213]:
In [1214]:
park["MDVP:APQ"].describe()
Out[1214]:
In [1215]:
sns.distplot(park["MDVP:APQ"])
Out[1215]:
In [1216]:
park["Shimmer:DDA"].describe()
Out[1216]:
In [1217]:
sns.distplot(park["Shimmer:DDA"])
Out[1217]:
In [1218]:
park["NHR"].describe()
Out[1218]:
In [1219]:
sns.distplot(park["NHR"])
Out[1219]:
In [1220]:
park["HNR"].describe()
Out[1220]:
In [1221]:
sns.distplot(park["HNR"])
Out[1221]:
In [1222]:
park["status"].describe()
Out[1222]:
In [1223]:
sns.countplot(park["status"])
Out[1223]:
In [1224]:
park["RPDE"].describe()
Out[1224]:
In [1225]:
sns.distplot(park["RPDE"])
Out[1225]:
In [1226]:
park["DFA"].describe()
Out[1226]:
In [1227]:
sns.distplot(park["DFA"])
Out[1227]:
In [1228]:
park["spread1"].describe()
Out[1228]:
In [1229]:
sns.distplot(park["spread1"])
Out[1229]:
In [1230]:
park["spread2"].describe()
Out[1230]:
In [1231]:
sns.distplot(park["spread2"])
Out[1231]:
In [1232]:
park["D2"].describe()
Out[1232]:
In [1233]:
sns.distplot(park["D2"])
Out[1233]:
In [1234]:
park["PPE"].describe()
Out[1234]:
In [1235]:
sns.distplot(park["PPE"])
Out[1235]:
From the univariate analysis, the following can be inferred
- From count plot out of 195 patients checked around 140 patients are suspected to have Parkinson.
- The columns D2,spread2,spread1 have a normal bell-shaped curve.
- The columns DFA, HNR are skewed towards the right.
- The rest of all columns are skewed towards left.
- The spread, mean, IQR, etc have been calculated.
Bivariate Analysis¶
In [1236]:
sns.pairplot(park[["MDVP:Fo(Hz)","MDVP:Fhi(Hz)","MDVP:Flo(Hz)","MDVP:Jitter(%)",
"MDVP:Jitter(Abs)","MDVP:RAP","MDVP:PPQ","Jitter:DDP","MDVP:Shimmer",
"MDVP:Shimmer(dB)","Shimmer:APQ3","Shimmer:APQ5","MDVP:APQ","Shimmer:DDA","NHR",
"HNR","status","RPDE","DFA","spread1","spread2","D2","PPE"]])
Out[1236]:
In [1237]:
core=park.corr()
park.corr()
Out[1237]:
In [1238]:
plt.figure(figsize = (21,15))
sns.heatmap(core,annot=True)
Out[1238]:
From the bivariate analysis, the following can be inferred
- Around 10 variables have a strong correlation.
- The pair plot of all the variables is plotted.
- The columns Jitter: DDP, DFA, MDVP: Fhi, NHR are deleted due to least significant of the variables.
In [1239]:
park.drop("name",axis=1,inplace=True)
park.drop("Jitter:DDP",axis=1,inplace=True)
park.drop("DFA",axis=1,inplace=True)
park.drop("MDVP:Fhi(Hz)",axis=1,inplace=True)
park.drop("NHR",axis=1,inplace=True)
4. Split the dataset into training and test set in the ratio of 70:30¶
In [1240]:
X= park.drop("status",axis=1)
Y= park["status"]
x_train,x_test,y_train,y_test = train_test_split(X,Y,test_size=0.3,random_state=1)
x_train.head()
Out[1240]:
In [1241]:
rep_0 = SimpleImputer(missing_values=0, strategy="mean")
cols=x_train.columns
x_train = pd.DataFrame(rep_0.fit_transform(x_train))
x_test = pd.DataFrame(rep_0.fit_transform(x_test))
x_train.columns = cols
x_test.columns = cols
x_train.head()
Out[1241]:
6. Train at least 3 standard classification algorithms¶
In [1242]:
model = LogisticRegression(solver="liblinear")
model.fit(x_train, y_train)
y_predict = model.predict(x_test)
coef_df = pd.DataFrame(model.coef_)
coef_df['intercept'] = model.intercept_
print(coef_df)
In [1243]:
model_score = model.score(x_test, y_test)
print(model_score)
In [1244]:
confusion_matrix(y_test, y_predict)
Out[1244]:
In [1245]:
cm=confusion_matrix(y_test, y_predict)
sns.heatmap(cm, annot=True)
Out[1245]:
In [1246]:
print("Classification Report")
print(metrics.classification_report(y_test,y_predict, labels=[1, 0]))
KNN Classifier¶
In [1247]:
park.groupby(["status"]).count()
Out[1247]:
In [1248]:
XScaled = X.apply(zscore)
XScaled.describe()
Out[1248]:
In [1249]:
X_train, X_test, Y_train, Y_test = train_test_split(XScaled, Y, test_size=0.30, random_state=42)
In [1250]:
NNH = KNeighborsClassifier(n_neighbors= 5 , weights = 'distance' )
In [1251]:
NNH.fit(X_train, Y_train)
Out[1251]:
In [1252]:
predicted_labels = NNH.predict(X_test)
NNH.score(X_test, Y_test)
Out[1252]:
In [1253]:
a=confusion_matrix(Y_test, predicted_labels)
print("confusion matirx of KNN classifier = \n",a)
In [1254]:
knnm=metrics.confusion_matrix(Y_test, predicted_labels)
knn_m = pd.DataFrame(knnm, index = [i for i in ["1","0"]],columns = [i for i in ["Predict 1","Predict 0"]])
plt.figure(figsize = (7,5))
sns.heatmap(knn_m, annot=True)
Out[1254]:
In [1255]:
print("Classification Report")
print(metrics.classification_report(Y_test, predicted_labels, labels=[1, 0]))
SVM classifier¶
In [1256]:
x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.3, random_state=42)
In [1257]:
svc_model = SVC(C= .1, kernel='linear', gamma= 1)
svc_model.fit(x_train, y_train)
prediction = svc_model .predict(x_test)
In [1258]:
print(svc_model.score(x_train, y_train))
print(svc_model.score(x_test, y_test))
In [1259]:
print("Confusion Matrix:\n",confusion_matrix(y_test,prediction))
In [1260]:
knnm=metrics.confusion_matrix(y_test,prediction)
knn_m = pd.DataFrame(knnm, index = [i for i in ["1","0"]],columns = [i for i in ["Predict 1","Predict 0"]])
plt.figure(figsize = (7,5))
sns.heatmap(knn_m, annot=True)
Out[1260]:
In [1261]:
print("Classification Report")
print(metrics.classification_report(y_test,prediction, labels=[1, 0]))
In [1262]:
svc_model = SVC(kernel='rbf')
svc_model.fit(x_train, y_train)
Out[1262]:
In [1263]:
svc_model = SVC(kernel='poly')
svc_model.fit(x_train, y_train)
prediction = svc_model.predict(x_test)
print(svc_model.score(x_train, y_train))
print(svc_model.score(x_test, y_test))
In [1264]:
svc_model = SVC(kernel='sigmoid')
svc_model.fit(x_train, y_train)
prediction = svc_model.predict(x_test)
print(svc_model.score(x_train, y_train))
print(svc_model.score(x_test, y_test))
8.Ensemble model¶
Decision Tree¶
In [1265]:
feature_cols = ['MDVP:Fo(Hz)',' MDVP:Flo(Hz)','MDVP:Jitter(%)','MDVP:Jitter(Abs)','MDVP:RAP','MDVP:PPQ','MDVP:Shimmer',
'MDVP:Shimmer(dB)','Shimmer:APQ3','Shimmer:APQ5','MDVP:APQ','Shimmer:DDA','HNR','RPDE','spread1','spread2','D2','PPE']
clf = DecisionTreeClassifier()
clf=clf.fit(x_train,y_train)
y_pred = clf.predict(x_test)
In [1266]:
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
In [1267]:
print("Confusion Matrix:\n",confusion_matrix(y_test,y_pred))
In [1268]:
tree=metrics.confusion_matrix(y_test,y_pred)
tree_m = pd.DataFrame(tree, index = [i for i in ["1","0"]],columns = [i for i in ["Predict 1","Predict 0"]])
plt.figure(figsize = (7,5))
sns.heatmap(tree_m, annot=True)
Out[1268]:
In [1269]:
print("Classification Report")
print(metrics.classification_report(y_test,y_pred, labels=[1, 0]))
In [1270]:
dot_data = StringIO()
export_graphviz(clf, out_file=dot_data,
filled=True, rounded=True,
special_characters=True,feature_names = feature_cols,class_names=['0','1'])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
graph.write_png('park.png')
Image(graph.create_png())
Out[1270]:
Pruned decision Tree¶
In [1271]:
clf = DecisionTreeClassifier(criterion="entropy", max_depth=3)
clf = clf.fit(x_train,y_train)
y_pred = clf.predict(x_test)
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
In [1272]:
dot_data = StringIO()
export_graphviz(clf, out_file=dot_data,
filled=True, rounded=True,
special_characters=True, feature_names = feature_cols,class_names=['0','1'])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
graph.write_png('park1.png')
Image(graph.create_png())
Out[1272]:
Random Forest¶
In [1273]:
rf = RandomForestClassifier(n_estimators = 70,criterion="entropy")
rf = rf.fit(x_train, y_train)
In [1274]:
predrf= rf.predict(x_test)
accrf = accuracy_score(y_test, predrf)
print(accrf)
In [1275]:
print("Confusion Matrix:\n",confusion_matrix(y_test,predrf))
In [1276]:
rf1=metrics.confusion_matrix(y_test,predrf)
rf1_m = pd.DataFrame(rf1, index = [i for i in ["1","0"]],columns = [i for i in ["Predict 1","Predict 0"]])
plt.figure(figsize = (7,5))
sns.heatmap(rf1_m, annot=True)
Out[1276]:
In [1277]:
print("Classification Report")
print(metrics.classification_report(y_test,predrf, labels=[1, 0]))
AdaBoost¶
In [1278]:
abc = AdaBoostClassifier(n_estimators=100,learning_rate=1)
model = abc.fit(x_train, y_train)
y_pred = model.predict(x_test)
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
In [1279]:
print("Confusion Matrix:\n",confusion_matrix(y_test,y_pred))
In [1280]:
ab=metrics.confusion_matrix(y_test,y_pred)
ab_m = pd.DataFrame(ab, index = [i for i in ["1","0"]],columns = [i for i in ["Predict 1","Predict 0"]])
plt.figure(figsize = (7,5))
sns.heatmap(ab_m, annot=True)
Out[1280]:
In [1281]:
print("Classification Report")
print(metrics.classification_report(y_test,y_pred, labels=[1, 0]))
Bagging Classifier¶
In [1282]:
bag = BaggingClassifier(n_estimators=100, max_samples= .7, bootstrap=True, oob_score=True, random_state=22)
bag= bag.fit(x_train, y_train)
In [1283]:
predBAG =bag.predict(x_test)
accBAG = accuracy_score(y_test, predBAG)
print(accBAG)
In [1284]:
print("Confusion Matrix:\n",confusion_matrix(y_test,predBAG))
In [1285]:
bag=metrics.confusion_matrix(y_test,predBAG)
bag_m = pd.DataFrame(bag, index = [i for i in ["1","0"]],columns = [i for i in ["Predict 1","Predict 0"]])
plt.figure(figsize = (7,5))
sns.heatmap(bag_m, annot=True)
Out[1285]:
In [1286]:
print("Classification Report")
print(metrics.classification_report(y_test,predBAG, labels=[1, 0]))
GradientBoost Classifier¶
In [1287]:
grad = GradientBoostingClassifier(n_estimators = 100, learning_rate = 0.1, random_state=42)
grad = grad.fit(x_train, y_train)
In [1288]:
predgrad =grad.predict(x_test)
accgrad = accuracy_score(y_test, predgrad)
print(accgrad)
In [1289]:
print("Confusion Matrix:\n",confusion_matrix(y_test,predgrad))
In [1290]:
grad=metrics.confusion_matrix(y_test,predgrad)
grad_m = pd.DataFrame(grad, index = [i for i in ["1","0"]],columns = [i for i in ["Predict 1","Predict 0"]])
plt.figure(figsize = (7,5))
sns.heatmap(grad_m, annot=True)
Out[1290]:
In [1291]:
print("Classification Report")
print(metrics.classification_report(y_test,predgrad, labels=[1, 0]))
7.meta-classifier¶
Stacking classifier¶
In [1292]:
clf1 = KNeighborsClassifier(n_neighbors=1)
clf2 = RandomForestClassifier(random_state=1)
clf3 =SVC(C= .1, kernel='linear', gamma= 1)
lr = LogisticRegression()
sclf = StackingClassifier(classifiers=[clf1, clf2, clf3], meta_classifier=lr)
print('3-fold cross validation:\n')
for clf, label in zip([clf1, clf2, clf3, sclf],
['KNN',
'Random Forest',
'Naive Bayes',
'StackingClassifier']):
scores = model_selection.cross_val_score(clf, X, Y,
cv=3, scoring='accuracy')
print("Accuracy: %0.2f (+/- %0.2f) [%s]"
% (scores.mean(), scores.std(), label))
9. Picking the best model¶
From the above models following are the accuracy
- Logistic Regression 78%
- KNN classifier 91%
- Support vector classifier 88%
- Decision Tree 86%
- Random Forest 90%
- Ada boosting classifier 86%
- Bagging Classifier 88%
- Gradient boosting Classifier 90%
- Meta-classifier(Stacking classifier) 87%. The meta classifier used was logistic regression.
From the above models, we get that
- The best model is the KNN classifier. It has an accuracy of 92%.\ The recall also is 92 which is good.\ Thus for the above reason, we select the KNN classifier is selected.
In [ ]: